.TH std::ranges::iter_move 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::ranges::iter_move \- std::ranges::iter_move

.SH Synopsis
   Defined in header <iterator>
   inline namespace /* unspecified */ {

       inline constexpr /* unspecified */ iter_move = /*   \fI(since C++20)\fP
   unspecified */;                                         (customization point object)

   }
   Call signature
   template< class T >

       requires /* see below */                            \fI(since C++20)\fP

   constexpr decltype(auto) iter_move( T&& t )
   noexcept(/* see below */);

   Obtains an rvalue reference or a prvalue temporary from a given iterator.

   A ranges::iter_move(t) is expression-equivalent to:

    1. iter_move(t), if t has a class or enumeration type and the expression is
       well-formed when treated as an unevaluated operand, where the overload
       resolution of iter_move is performed only with the candidates found by
       argument-dependent lookup.
    2. Otherwise, std::move(*t) if *t is well-formed and is an lvalue.
    3. Otherwise, *t if *t is well-formed and is an rvalue.

   In all other cases, a call to ranges::iter_move is ill-formed, which can result in
   substitution failure when ranges::iter_move(e) appears in the immediate context of a
   template instantiation.

   If ranges::iter_move(e) is not equal to *e, the program is ill-formed, no diagnostic
   required.

  Customization point objects

   The name ranges::iter_move denotes a customization point object, which is a const
   function object of a literal semiregular class type. For exposition purposes, the
   cv-unqualified version of its type is denoted as __iter_move_fn.

   All instances of __iter_move_fn are equal. The effects of invoking different
   instances of type __iter_move_fn on the same arguments are equivalent, regardless of
   whether the expression denoting the instance is an lvalue or rvalue, and is
   const-qualified or not (however, a volatile-qualified instance is not required to be
   invocable). Thus, ranges::iter_move can be copied freely and its copies can be used
   interchangeably.

   Given a set of types Args..., if std::declval<Args>()... meet the requirements for
   arguments to ranges::iter_move above, __iter_move_fn models

     * std::invocable<__iter_move_fn, Args...>,
     * std::invocable<const __iter_move_fn, Args...>,
     * std::invocable<__iter_move_fn&, Args...>, and
     * std::invocable<const __iter_move_fn&, Args...>.

   Otherwise, no function call operator of __iter_move_fn participates in overload
   resolution.

.SH Example

    This section is incomplete
    Reason: no example

.SH See also

   iter_move casts the result of dereferencing the adjusted underlying iterator to its
   (C++20)   associated rvalue reference type
             \fI(function)\fP
   iter_move casts the result of dereferencing the underlying iterator to its
   (C++20)   associated rvalue reference type
             \fI(function)\fP

.SH Category:
     * Todo no example
